﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;

namespace SJ.Platform.Extend.Request
{
    public class ApiRequest<T>
    {       
        public T? Condition { get; set; }

        /// <summary>
        /// 生成Lambda条件表达式
        /// </summary>
        /// <returns></returns>
        public static Expression<Func<T, bool>> GenerateCondition(T condition)
        {
            var paramExpr = Expression.Parameter(typeof(T), "t");

            // 创建一个初始条件为 true 的表达式
            Expression bodyExpr = Expression.Constant(true);

            ////获取T的名称
            //var tName = typeof(T).Name;
            //string extName = tName + "QueryExtend";

            // 获取 T 类型的所有属性
            var properties = typeof(T).GetProperties();

            foreach (var prop in properties)
            {
                var conditionValue = prop.GetValue(condition);

                // 跳过空值或空字符串（对于非字符串类型，空值检查仍适用）  
                if (conditionValue == null || (prop.PropertyType == typeof(string) && string.IsNullOrWhiteSpace(conditionValue.ToString())))
                    continue;

                Expression propertyExpr = Expression.Property(paramExpr, prop.Name);

                // 根据属性类型构建条件表达式  
                Expression conditionExpr;
                if (prop.PropertyType == typeof(string))
                {
                    // 对于字符串，使用 Contains 方法进行模糊匹配  
                    MethodInfo containsMethod = typeof(string).GetMethod("Contains", new[] { typeof(string) });
                    conditionExpr = Expression.Call(propertyExpr, containsMethod, Expression.Constant(conditionValue.ToString(), typeof(string)));
                }
                else
                {
                    // 对于其他类型（如 int），使用 Equal  
                    conditionExpr = Expression.Equal(propertyExpr, Expression.Constant(conditionValue, prop.PropertyType));
                }

                // 将条件表达式添加到总体条件中  
                bodyExpr = Expression.AndAlso(bodyExpr, conditionExpr);
            }

            // 创建 Lambda 表达式
            var lambdaExpr = Expression.Lambda<Func<T, bool>>(bodyExpr, paramExpr);

            return lambdaExpr;
        }
    }
}
